…d adapter wiring

Adds the runtime-side governance subsystem behind the
``EnablePythonGovernanceChecker`` feature flag. When the flag is off,
none of this is imported — the gate is at
``src/uipath/runtime/wrapper.py:apply_governance_wrapper`` and the
governance subtree stays off the startup path.

Architecture:
- ``src/uipath/runtime/governance/wrapper.py:GovernanceRuntime`` —
  proxies the wrapped runtime, fires BEFORE_AGENT / AFTER_AGENT at the
  runtime boundary, materialises the evaluator + framework adapter
  lazily on the first hook fire. Step-isolated dispose; init
  side-effects (model-name ContextVar, agent-type selector, prefetch)
  all live behind the FF gate so an FF-off path is a true no-op.
- ``src/uipath/runtime/governance/native/`` — in-process policy
  evaluator: policy fetch (size-bounded, currency-anchored amount
  detection, expanded verb pattern for proposal/SOW commitments),
  YAML-to-index compiler, bounded-pool compensating /runtime/govern
  call, agent-type query param (conversational vs autonomous),
  job-context payload (folder/job/process/agent/version keys).
- ``src/uipath/runtime/governance/audit/`` — pluggable sink framework
  with a background-thread queue. Default sinks: traces (OTel spans,
  always on, platform-mandated) and console (stderr, opt-in via
  ``UIPATH_GOVERNANCE_CONSOLE_LOG``). Sink failures circuit-break
  after 10 consecutive errors; counters reset on re-register so a
  fresh instance doesn't inherit a tripped state. ``close()`` shutdown
  is bounded — ``put_nowait`` sentinel + ``_shutdown.set()`` signal so
  a wedged sink can't hang process exit.
- ``src/uipath/runtime/governance/delegation_guard.py`` — async-aware
  depth guard, patches both ``invoke`` and ``ainvoke`` with sync/async
  wrappers matched via ``iscoroutinefunction``. Per-agent depths live
  in a single module-level ``ContextVar[dict[id(agent), int]]`` —
  ContextVars are interned by the interpreter and never GC'd, so the
  prior one-ContextVar-per-agent design was an unbounded leak.
- ``src/uipath/runtime/governance/audit/traces.py`` — rule-level OTel
  span surfaces matched non-allow actions as ``Status.ERROR``
  (including audit-mode violations the runtime intentionally didn't
  block). Hook spans stay UNSET; severity belongs on the rule that
  fired.
- ``src/uipath/runtime/registry.py`` — ``UiPathWrappedRuntimeFactory``
  wraps every registered factory so every runtime it produces passes
  through ``apply_governance_wrapper``.

Notable contracts:
- ``_extract_governable_text`` (wrapper.py): pulls clean content out
  of arbitrary runtime payloads. Walks dicts (priority keys: content /
  text / output / answer / message / result / arguments / thinking),
  list-of-blocks, pydantic models, dataclasses, plain objects. Cycle-
  safe, depth-capped, 8000-char budget. Replaces the prior
  ``str(value)[:2000]`` shortcut that produced dict-repr garble.
- ``commitment_concern`` (``A.10.4``): OR semantics with currency-
  anchored amount detection. Verb pattern covers first-person promise
  verbs and proposal/SOW markers ("Cost: $X", "fixed scope",
  "Deliverables", "Timeline: N days", "I propose"). Bare percentages
  intentionally not matched — they false-positive on status text.
- Compensation payload: ``FiredRule`` TypedDict carries per-rule
  metadata for LLMOps trace records; the validators list is derived
  from it.
- Job-context resolution: memoized once per process via
  ``functools.lru_cache``; tests can invalidate via ``cache_clear``.
- Process-level governance state (conversational selector,
  job-context cache) reset between tests via an autouse fixture in
  ``tests/conftest.py``.

Tests (225 passing):
- ``tests/test_evaluator.py`` — core evaluator + wrapper / adapter
  integration via captured audit events.
- ``tests/test_commitment_concern.py`` — verb/amount/deadline OR
  semantics, the proposal-style sample that originally slipped past
  the rule, URL-fragment digits don't false-positive, percentage-only
  status text stays silent.
- ``tests/test_delegation_guard.py`` — sync + async wrapper shapes,
  shared depth counter across modes, leak fix (100 install/uninstall
  cycles keep one ContextVar), multi-agent isolation.
- ``tests/test_dispose_isolation.py`` — each governance-side dispose
  step survives upstream failures; delegate dispose still propagates.
- ``tests/test_text_extraction.py`` — dict / list-of-blocks /
  pydantic / dataclass / cycle / budget cap.
- ``tests/test_audit_register_sink.py`` — sink failure counter reset
  on re-register, duplicate register is a no-op, full lifecycle.
- ``tests/test_traces_severity.py`` — rule span ERROR for matched
  non-allow, hook span stays UNSET regardless of final_action.
- ``tests/test_guardrail_compensation.py`` — compensating /govern call
  payload, headers, URL composition, evaluator integration.
- ``tests/test_policy_agent_type.py`` — conversational vs autonomous
  selector, policy URL query param.
- ``tests/test_registry.py`` — factory wrapping, governance attached
  to every registered factory.
- ``tests/test_wrapper.py`` — FF gate + lazy-import contract.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

…tiate audit vs enforce severity in traces

Text extraction (wrapper.py):
- Add "messages" to priority content keys for LangGraph-style state
  ({"messages": [...]}) so chat history leads the extracted blob.
- Walk lists newest-first so the latest message wins the budget when
  the conversation grows.
- New latest_only flag (passed by BEFORE_AGENT) reduces the chat
  history to the most recent message; flag resets on recursion so
  multi-block content within that message is still walked fully.
- Raise text cap 8K -> 64K to fit multi-turn chat.

Trace severity (audit/traces.py):
- Differentiate "actually blocked" from "advisory" violations:
  enforce-mode deny/escalate -> severity=ERROR + StatusCode.ERROR;
  audit-mode (any action) or enforce-mode audit-action -> severity=
  WARNING, Status left UNSET so the agent span isn't falsely marked
  failed.

Tests cover reverse list walk, latest_only semantics, the 64K cap,
and the audit/enforce severity matrix.